{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import io\n",
    "import sympy\n",
    "from IPython.display import display, Latex\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from roboticstoolbox import RevoluteDH, DHRobot\n",
    "from spatialmath import SE3\n",
    "import spatialmath.base as base\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T01:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C1, -S1, 0, 0],\n",
      "[S1,  C1, 0, 0],\n",
      "[ 0,   0, 1, 0],\n",
      "[ 0,   0, 0, 1]])>\n",
      "T12:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C2, -S2, 0, L1],\n",
      "[S2,  C2, 0,  0],\n",
      "[ 0,   0, 1,  0],\n",
      "[ 0,   0, 0,  1]])>\n",
      "T23:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3, -S3, 0, L2],\n",
      "[S3,  C3, 0,  0],\n",
      "[ 0,   0, 1,  0],\n",
      "[ 0,   0, 0,  1]])>\n",
      "T3H:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[1, 0, 0, L3],\n",
      "[0, 1, 0,  0],\n",
      "[0, 0, 1,  0],\n",
      "[0, 0, 0,  1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), T03 should be: \n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1), C3*(-C1*S2 - C2*S1) - S3*(C1*C2 - S1*S2), 0, C1*L1 + L2*(C1*C2 - S1*S2)],\n",
      "[ C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2),  C3*(C1*C2 - S1*S2) - S3*(C1*S2 + C2*S1), 0, L1*S1 + L2*(C1*S2 + C2*S1)],\n",
      "[                                       0,                                        0, 1,                          0],\n",
      "[                                       0,                                        0, 0,                          1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), T0H should be: \n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1), C3*(-C1*S2 - C2*S1) - S3*(C1*C2 - S1*S2), 0, C1*L1 + L2*(C1*C2 - S1*S2) + L3*(C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1))],\n",
      "[ C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2),  C3*(C1*C2 - S1*S2) - S3*(C1*S2 + C2*S1), 0,  L1*S1 + L2*(C1*S2 + C2*S1) + L3*(C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2))],\n",
      "[                                       0,                                        0, 1,                                                                          0],\n",
      "[                                       0,                                        0, 0,                                                                          1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T03 should be: \n",
      "    T03 = <bound method MatrixProperties.values of Matrix([\n",
      "[-1.83697019872103e-16,                   1.0, 0, -3.0],\n",
      "[                 -1.0, -1.83697019872103e-16, 0,  4.0],\n",
      "[                    0,                     0, 1,    0],\n",
      "[                    0,                     0, 0,    1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T0H should be: \n",
      "    T0H = <bound method MatrixProperties.values of Matrix([\n",
      "[-1.83697019872103e-16,                   1.0, 0, -3.0],\n",
      "[                 -1.0, -1.83697019872103e-16, 0,  2.0],\n",
      "[                    0,                     0, 1,    0],\n",
      "[                    0,                     0, 0,    1]])>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(Matrix([\n",
       " [-1.83697019872103e-16,                   1.0, 0, -3.0],\n",
       " [                 -1.0, -1.83697019872103e-16, 0,  4.0],\n",
       " [                    0,                     0, 1,    0],\n",
       " [                    0,                     0, 0,    1]]),\n",
       " Matrix([\n",
       " [-1.83697019872103e-16,                   1.0, 0, -3.0],\n",
       " [                 -1.0, -1.83697019872103e-16, 0,  2.0],\n",
       " [                    0,                     0, 1,    0],\n",
       " [                    0,                     0, 0,    1]]))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class myRobot1(DHRobot):\n",
    "    def __init__(self):\n",
    "        super().__init__(\n",
    "            [\n",
    "                RevoluteDH(a=4),\n",
    "                RevoluteDH(a=3),\n",
    "                RevoluteDH(a=2),\n",
    "            ], name=\"toFinal\")\n",
    "\n",
    "class myRobot2(DHRobot):\n",
    "    def __init__(self):\n",
    "        super().__init__(\n",
    "            [\n",
    "                RevoluteDH(a=4),\n",
    "                RevoluteDH(a=3),\n",
    "                RevoluteDH()\n",
    "            ], name=\"toThird\")\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "From here, answer for Exp 3 begins.\n",
    "\"\"\"\n",
    "\n",
    "def getResultsByHandInExp3(theta1_value, theta2_value, theta3_value):\n",
    "    C1, C2, C3, S1, S2, S3 = sympy.symbols(\"C1 C2 C3 S1 S2 S3\")\n",
    "\n",
    "    C1_value, C2_value, C3_value = math.cos(theta1_value * math.pi / 180), math.cos(theta2_value * math.pi / 180), math.cos(theta3_value * math.pi / 180)\n",
    "    S1_value, S2_value, S3_value = math.sin(theta1_value * math.pi / 180), math.sin(theta2_value * math.pi / 180), math.sin(theta3_value * math.pi / 180)\n",
    "    L1_value, L2_value, L3_value = 4, 3, 2\n",
    "\n",
    "    L1, L2, L3 = sympy.symbols(\"L1 L2 L3\")\n",
    "    T01 = sympy.Matrix([\n",
    "        [C1, -S1, 0, 0],\n",
    "        [S1, C1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ])\n",
    "    T12 = sympy.Matrix([\n",
    "        [1, 0, 0, L1],\n",
    "        [0, 1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ]) * sympy.Matrix([\n",
    "        [C2, -S2, 0, 0],\n",
    "        [S2, C2, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ])\n",
    "\n",
    "    T23 = sympy.Matrix([\n",
    "        [1, 0, 0, L2],\n",
    "        [0, 1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ]) * sympy.Matrix([\n",
    "        [C3, -S3, 0, 0],\n",
    "        [S3, C3, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ])\n",
    "\n",
    "    T3H = sympy.Matrix([\n",
    "        [1, 0, 0, L3],\n",
    "        [0, 1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ])\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    print(\"T01:\")\n",
    "    print(\"    \", T01.values)\n",
    "\n",
    "    print(\"T12:\")\n",
    "    print(\"    \", T12.values)\n",
    "\n",
    "    print(\"T23:\")\n",
    "    print(\"    \", T23.values)\n",
    "\n",
    "    print(\"T3H:\")\n",
    "    print(\"    \", T3H.values)\n",
    "\n",
    "    T03 = T01 * T12 * T23\n",
    "\n",
    "    T0H = T03 * T3H\n",
    "    print(\"Solve By Hand (WITHOUT packages about ROBOTICS), T03 should be: \")\n",
    "    print(\"    \", T03.values)\n",
    "\n",
    "    print(\"Solve By Hand (WITHOUT packages about ROBOTICS), T0H should be: \")\n",
    "    print(\"    \", T0H.values)\n",
    "\n",
    "    print(\"Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T03 should be: \")\n",
    "    print(f\"    T03 = {T03.subs({C1:C1_value, C2:C2_value, C3:C3_value, S1:S1_value, S2:S2_value, S3:S3_value, L1:L1_value, L2:L2_value, L3:L3_value, }).values}\")\n",
    "\n",
    "    print(\"Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T0H should be: \")\n",
    "    print(f\"    T0H = {T0H.subs({C1:C1_value, C2:C2_value, C3:C3_value, S1:S1_value, S2:S2_value, S3:S3_value, L1:L1_value, L2:L2_value, L3:L3_value, }).values}\")\n",
    "\n",
    "    return T03.subs({C1:C1_value, C2:C2_value, C3:C3_value, S1:S1_value, S2:S2_value, S3:S3_value, L1:L1_value, L2:L2_value, L3:L3_value, }), \\\n",
    "            T0H.subs({C1:C1_value, C2:C2_value, C3:C3_value, S1:S1_value, S2:S2_value, S3:S3_value, L1:L1_value, L2:L2_value, L3:L3_value, })\n",
    "\n",
    "getResultsByHandInExp3(90, 90, 90)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T03 should be: \n",
      "   0         1         0        -3         \n",
      "  -1         0         0         4         \n",
      "   0         0         1         0         \n",
      "   0         0         0         1         \n",
      "\n",
      "Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T0H should be: \n",
      "   0         1         0        -3         \n",
      "  -1         0         0         2         \n",
      "   0         0         1         0         \n",
      "   0         0         0         1         \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(   0         1         0        -3         \n",
       "  -1         0         0         4         \n",
       "   0         0         1         0         \n",
       "   0         0         0         1         \n",
       ",\n",
       "    0         1         0        -3         \n",
       "  -1         0         0         2         \n",
       "   0         0         1         0         \n",
       "   0         0         0         1         \n",
       ")"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def getResultsByDHRobotInExp3(q = base.sym.symbol(\"ϴ_1:4\")):\n",
    "    deg = math.pi / 180\n",
    "    q_ = q\n",
    "    for i in range(len(q_)):\n",
    "        q_[i] *= deg\n",
    "\n",
    "    toFinal = myRobot1()\n",
    "    toThird = myRobot2()\n",
    "    T03 = toThird.fkine(q_)\n",
    "    T0H = toFinal.fkine(q_)\n",
    "    print(\"Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T03 should be: \")\n",
    "    print(T03)\n",
    "    print(\"Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T0H should be: \")\n",
    "    print(T0H)\n",
    "    return T03, T0H\n",
    "\n",
    "getResultsByDHRobotInExp3([90, 90, 90])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "From here, Answer for Exp 4 begins.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "def chapter4Experiment(T:SE3):\n",
    "    # print(T)\n",
    "    T = np.array(T.data[0])\n",
    "    # print(T)\n",
    "    T3H = np.array(([\n",
    "        [1, 0, 0, 2.0],\n",
    "        [0, 1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ]))\n",
    "    \n",
    "\n",
    "    T = np.matmul(T, np.linalg.inv(T3H))\n",
    "    # print(T)\n",
    "    T = SE3(T, check=False)\n",
    "    toFinal = myRobot2()\n",
    "    thetas = toFinal.ikine_LM(T)\n",
    "    print(thetas)\n",
    "\n",
    "\n",
    "def chapter4MySolution(T : np.array):\n",
    "    T = T.copy()\n",
    "\n",
    "    T3H = np.array(([\n",
    "        [1, 0, 0, 2.0],\n",
    "        [0, 1, 0, 0],\n",
    "        [0, 0, 1, 0],\n",
    "        [0, 0, 0, 1]\n",
    "    ]))\n",
    "    \n",
    "\n",
    "    T = np.matmul(T, np.linalg.inv(T3H))\n",
    "\n",
    "    # print(T)\n",
    "    \n",
    "    # c2 = ((T[0][3] - T[0][0] * 2) * (T[0][3] - T[0][0] * 2) + (T[1][3] - T[1][0] * 2) * (T[1][3] - T[1][0] * 2) - 25) / 24\n",
    "    c2 = ((T[0][3]) * (T[0][3]) + (T[1][3]) * (T[1][3]) - 25) / 24\n",
    "    ans = []\n",
    "    if abs(c2) > 1:\n",
    "        print(\"ERROR: Too Far That Can't Reach.\")\n",
    "        return\n",
    "\n",
    "    def getTheta1and3(theta2):\n",
    "        k1 = 4 + 3 * math.cos(theta2)\n",
    "        k2 = 3 * math.sin(theta2)\n",
    "        r = math.sqrt(k1 * k1 + k2 * k2)\n",
    "        theta1 = math.atan2(T[1][3], T[0][3]) - math.atan2(k2, k1)\n",
    "        fi = math.atan2(T[1][0], T[0][0])\n",
    "        theta3 = fi - theta1 - theta2\n",
    "        return theta1, theta3\n",
    "\n",
    "    theta2 = math.acos(c2)\n",
    "    theta1, theta3 = getTheta1and3(theta2)\n",
    "    ans.append([theta1 / math.pi * 180, theta2 / math.pi * 180, theta3 / math.pi * 180])\n",
    "\n",
    "    theta2 = -theta2\n",
    "    theta1, theta3 = getTheta1and3(theta2)\n",
    "    ans.append([theta1 / math.pi * 180, theta2 / math.pi * 180, theta3 / math.pi * 180])\n",
    "\n",
    "    # for i in range(len(ans)):\n",
    "    #     for j in range(len(ans[i])):\n",
    "    #         ans[i][j] *= 180\n",
    "\n",
    "    # print(\"My Solutions are:\")\n",
    "    print(ans)\n",
    "\n",
    "\n",
    "def chapter4Solution():\n",
    "\n",
    "    print(\"Solution For First Problem in b\")\n",
    "    T1 = SE3(np.array([[1.0, 0, 0, 9], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))\n",
    "    chapter4Experiment(T1)\n",
    "\n",
    "    print(\"Solution For Second Problem in b\")\n",
    "    T2 = SE3(np.array([[0.5, -0.866, 0, 7.5373], [0.866, 0.5, 0, 3.9266], [0, 0, 1, 0], [0, 0, 0, 1]]),check = False)\n",
    "    chapter4Experiment(T2)\n",
    "\n",
    "    print(\"Solution For Third Problem in b\")\n",
    "    T3 = SE3(np.array([[0, 1, 0, -3], [-1, 0, 0, 2], [0, 0, 1, 0], [0, 0, 0, 1]]))\n",
    "    chapter4Experiment(T3)\n",
    "\n",
    "    print(\"Solution For Forth Problem in b\")\n",
    "    T4 = SE3(np.array([[0.866, -0.5, 0, -3.1245], [-0.5, 0.866, 0, 8.1674], [0, 0, 1, 0], [0, 0, 0, 1]]), check=False)\n",
    "    chapter4Experiment(T4)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def chapter4MySolutions():\n",
    "    print(\"My Solution For First Problem in b\")\n",
    "    chapter4MySolution(np.array([[1, 0, 0, 9], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))\n",
    "    print(\"My Solution For Second Problem in b\")\n",
    "    chapter4MySolution(np.array([[0.5, -0.866, 0, 7.5373], [0.866, 0.5, 0, 3.9266], [0, 0, 1, 0], [0, 0, 0, 1]]))\n",
    "    print(\"My Solution For Third Problem in b\")\n",
    "    chapter4MySolution(np.array([[0, 1, 0, -3], [-1, 0, 0, 2], [0, 0, 1, 0], [0, 0, 0, 1]]))\n",
    "    print(\"My Solution For Forth Problem in b\")\n",
    "    chapter4MySolution(np.array([[0.866, -0.5, 0, -3.1245], [-0.5, 0.866, 0, 8.1674], [0, 0, 1, 0], [0, 0, 0, 1]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Solution For First Problem in b\n",
      "[[0.0, 0.0, 0.0], [0.0, -0.0, 0.0]]\n",
      "My Solution For Second Problem in b\n",
      "[[9.999890653254626, 20.000435892798983, 29.998945673119014], [27.114360713650996, -20.000435892798983, 52.885347398320604]]\n",
      "My Solution For Third Problem in b\n",
      "[[90.0, 90.0, -270.0], [163.73979529168804, -90.0, -163.73979529168804]]\n",
      "My Solution For Forth Problem in b\n",
      "ERROR: Too Far That Can't Reach.\n",
      "Solution For First Problem in b\n",
      "IKsolution(q=array([0., 0., 0.]), success=True, reason=None, iterations=1, residual=0)\n",
      "Solution For Second Problem in b\n",
      "IKsolution(q=array([0.17453102, 0.34907346, 0.52358037]), success=True, reason=None, iterations=11, residual=7.56282697934437e-11)\n",
      "Solution For Third Problem in b\n",
      "IKsolution(q=array([1.57079633, 1.57079633, 1.57079633]), success=True, reason=None, iterations=19, residual=3.0444340481870957e-13)\n",
      "Solution For Forth Problem in b\n",
      "IKsolution(q=array([ 2.05796567e+00,  6.13092314e-09, -2.05796566e+00]), success=False, reason='rejected-step limit 100 exceeded', iterations=418, residual=3.3743344369651007)\n"
     ]
    }
   ],
   "source": [
    "chapter4MySolutions()\n",
    "chapter4Solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T01:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C1, -S1, 0, 0],\n",
      "[S1,  C1, 0, 0],\n",
      "[ 0,   0, 1, 0],\n",
      "[ 0,   0, 0, 1]])>\n",
      "T12:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C2, -S2, 0, L1],\n",
      "[S2,  C2, 0,  0],\n",
      "[ 0,   0, 1,  0],\n",
      "[ 0,   0, 0,  1]])>\n",
      "T23:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3, -S3, 0, L2],\n",
      "[S3,  C3, 0,  0],\n",
      "[ 0,   0, 1,  0],\n",
      "[ 0,   0, 0,  1]])>\n",
      "T3H:\n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[1, 0, 0, L3],\n",
      "[0, 1, 0,  0],\n",
      "[0, 0, 1,  0],\n",
      "[0, 0, 0,  1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), T03 should be: \n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1), C3*(-C1*S2 - C2*S1) - S3*(C1*C2 - S1*S2), 0, C1*L1 + L2*(C1*C2 - S1*S2)],\n",
      "[ C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2),  C3*(C1*C2 - S1*S2) - S3*(C1*S2 + C2*S1), 0, L1*S1 + L2*(C1*S2 + C2*S1)],\n",
      "[                                       0,                                        0, 1,                          0],\n",
      "[                                       0,                                        0, 0,                          1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), T0H should be: \n",
      "     <bound method MatrixProperties.values of Matrix([\n",
      "[C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1), C3*(-C1*S2 - C2*S1) - S3*(C1*C2 - S1*S2), 0, C1*L1 + L2*(C1*C2 - S1*S2) + L3*(C3*(C1*C2 - S1*S2) + S3*(-C1*S2 - C2*S1))],\n",
      "[ C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2),  C3*(C1*C2 - S1*S2) - S3*(C1*S2 + C2*S1), 0,  L1*S1 + L2*(C1*S2 + C2*S1) + L3*(C3*(C1*S2 + C2*S1) + S3*(C1*C2 - S1*S2))],\n",
      "[                                       0,                                        0, 1,                                                                          0],\n",
      "[                                       0,                                        0, 0,                                                                          1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T03 should be: \n",
      "    T03 = <bound method MatrixProperties.values of Matrix([\n",
      "[1.0,   0, 0, 7.0],\n",
      "[  0, 1.0, 0,   0],\n",
      "[  0,   0, 1,   0],\n",
      "[  0,   0, 0,   1]])>\n",
      "Solve By Hand (WITHOUT packages about ROBOTICS), Answer to T0H should be: \n",
      "    T0H = <bound method MatrixProperties.values of Matrix([\n",
      "[1.0,   0, 0, 9.0],\n",
      "[  0, 1.0, 0,   0],\n",
      "[  0,   0, 1,   0],\n",
      "[  0,   0, 0,   1]])>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(Matrix([\n",
       " [1.0,   0, 0, 7.0],\n",
       " [  0, 1.0, 0,   0],\n",
       " [  0,   0, 1,   0],\n",
       " [  0,   0, 0,   1]]),\n",
       " Matrix([\n",
       " [1.0,   0, 0, 9.0],\n",
       " [  0, 1.0, 0,   0],\n",
       " [  0,   0, 1,   0],\n",
       " [  0,   0, 0,   1]]))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getResultsByHandInExp3(0, 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T03 should be: \n",
      "   0.5      -0.866     0         6.116     \n",
      "   0.866     0.5       0         3.186     \n",
      "   0         0         1         0         \n",
      "   0         0         0         1         \n",
      "\n",
      "Solve By DHRobot (DBRobot is a package about ROBOTICS), Answer to T0H should be: \n",
      "   0.5      -0.866     0         7.116     \n",
      "   0.866     0.5       0         4.918     \n",
      "   0         0         1         0         \n",
      "   0         0         0         1         \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(   0.5      -0.866     0         6.116     \n",
       "   0.866     0.5       0         3.186     \n",
       "   0         0         1         0         \n",
       "   0         0         0         1         \n",
       ",\n",
       "    0.5      -0.866     0         7.116     \n",
       "   0.866     0.5       0         4.918     \n",
       "   0         0         1         0         \n",
       "   0         0         0         1         \n",
       ")"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getResultsByDHRobotInExp3([18.96028596135714, 20.000435892798983, 21.0385503650165])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "From here, answer for Exp 5 begins.\n",
    "\"\"\"\n",
    "\n",
    "def getThetaChangeByHandInExp5(theta1_value, theta2_value, theta3_value, L1 = 4, L2 = 3, L3 = 2):\n",
    "    deg = 180 / math.pi\n",
    "    F = np.array([1., 2., 3.])\n",
    "    C1, C12, C123 = math.cos(theta1_value), math.cos((theta1_value + theta2_value)), math.cos((theta1_value + theta2_value + theta3_value))\n",
    "    S1, S12, S123 = math.sin(theta1_value), math.sin((theta1_value + theta2_value)), math.sin((theta1_value + theta2_value + theta3_value))\n",
    "\n",
    "    X_d = np.array([0.2, -0.3, -0.2])\n",
    "\n",
    "    J = np.array([\n",
    "        [-L1 * S1 - L2 * S12 - L3 * S123, -L2 * S12 - L3 * S123, -L3 * S123],\n",
    "        [L1 * C1 + L2 * C12 + L3 * C123, L2 * C12 + L3 * C123, L3 * C123],\n",
    "        [1, 1, 1],\n",
    "    ])\n",
    "\n",
    "    tao = np.matmul(J.T, F)\n",
    "\n",
    "    det = np.linalg.det(J)\n",
    "\n",
    "    theta_d = np.matmul(np.linalg.inv(J), X_d)\n",
    "    \n",
    "    # print(r\"Solve By Hand (WITHOUT packages about ROBOTICS), theta_d should be: \")\n",
    "    # print(\"    \", theta_d)\n",
    "\n",
    "    return theta_d, det, tao\n",
    "\n",
    "def getResultsByHandInExp5(start = [10.0 / 180 * math.pi, 20.0 / 180 * math.pi, 30.0 / 180 * math.pi]):\n",
    "    robot = myRobot1()\n",
    "    \n",
    "    theta_d_container = {\"theta1\":[], \"theta2\":[], \"theta3\":[]}\n",
    "    theta_container = {\"theta1\":[start[0]], \"theta2\":[start[1]], \"theta3\":[start[2]]}\n",
    "    tao_container = {\"tao1\":[], \"tao2\":[], \"tao3\":[]}\n",
    "    theta = np.array(start)\n",
    "    thetas = [theta]\n",
    "    dets = []\n",
    "    lengths = []\n",
    "    for i in range(50):\n",
    "        theta_d, det, tao = getThetaChangeByHandInExp5(theta[0], theta[1], theta[2])\n",
    "        tao_container[\"tao1\"].append(tao[0])\n",
    "        tao_container[\"tao2\"].append(tao[1])\n",
    "        tao_container[\"tao3\"].append(tao[2])\n",
    "        dets.append(det)\n",
    "        theta_d_container[\"theta1\"].append(theta_d[0])\n",
    "        theta_d_container[\"theta2\"].append(theta_d[1])\n",
    "        theta_d_container[\"theta3\"].append(theta_d[2])\n",
    "        theta += theta_d * 0.1\n",
    "        # _, M = getResultsByHandInExp3(theta[0], theta[1], theta[2])\n",
    "\n",
    "        # length = math.sqrt(M.tolist()[0][3] ** 2 + M.tolist()[1][3] ** 2)\n",
    "        # lengths.append(length)\n",
    "        theta_container[\"theta1\"].append(theta[0])\n",
    "        theta_container[\"theta2\"].append(theta[1])\n",
    "        theta_container[\"theta3\"].append(theta[2])\n",
    "        thetas.append(theta.tolist())\n",
    "    # robot.plot(np.array(thetas))\n",
    "    plt.plot(dets)\n",
    "    plt.xlabel(\"time\")\n",
    "    plt.ylabel(\"det\")\n",
    "    plt.show()\n",
    "    plt.plot(tao_container[\"tao2\"], label = \"tao2\")\n",
    "    plt.plot(tao_container[\"tao1\"], label = \"tao1\")\n",
    "    plt.plot(tao_container[\"tao3\"], label = \"tao3\")\n",
    "    plt.xlabel(\"time\")\n",
    "    plt.ylabel(\"tao\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    plt.plot(theta_container[\"theta2\"], label = \"theta2\")\n",
    "    plt.plot(theta_container[\"theta1\"], label = \"theta1\")\n",
    "    plt.plot(theta_container[\"theta3\"], label = \"theta3\")\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"time\")\n",
    "    plt.ylabel(\"theta\")\n",
    "    plt.title(\"Joint Angles\")\n",
    "    plt.show()\n",
    "    plt.plot(theta_d_container[\"theta2\"], label = \"theta2\")\n",
    "    plt.plot(theta_d_container[\"theta1\"], label = \"theta1\")\n",
    "    plt.plot(theta_d_container[\"theta3\"], label = \"theta3\")\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"time\")\n",
    "    plt.ylabel(\"theta change rate\")\n",
    "    plt.title(\"Joint Rates\")\n",
    "    plt.show()\n",
    "\n",
    "getResultsByHandInExp5()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "From here, answer for Exp 6 begins.\n",
    "\"\"\"\n",
    "def getResultsByHandInExp6(start = [10.0 / 180 * math.pi, 20.0 / 180 * math.pi, 30.0 / 180 * math.pi]):\n",
    "    theta_d = np.array([0., 1., 2., 3.])\n",
    "    theta_dd = np.array([0., 0.5, 1, 1.5])\n",
    "    R = [[None, None, None, None], [None, None, None, None], [None, None, None, None], [None, None, None, None, None]]\n",
    "    S1, S2, S3, C1, C2, C3 = math.sin(start[0]), math.sin(start[1]), math.sin(start[2]), math.cos(start[0]), math.cos(start[1]), math.cos(start[2])\n",
    "    P = [[None, None, None, None], [None, None, None, None], [None, None, None, None], [None, None, None, None, None]]\n",
    "    Pc = [None, None, None, None]\n",
    "    m = [None, 20, 15, 10]\n",
    "    I = [None, None, None, None]\n",
    "    f = [None, None, None, None, np.array([0., 0., 0.])]\n",
    "    n = [None, None, None, None, np.array([0., 0., 0.])]\n",
    "    P[0][1] = np.array([0., 0., 0.])\n",
    "    P[1][2] = np.array([4., 0., 0.]) \n",
    "    P[2][3] = np.array([3., 0., 0.]) \n",
    "    P[3][4] = np.array([2., 0., 0.])\n",
    "    Pc[1] = np.array([2., 0., 0.]) \n",
    "    Pc[2] = np.array([1.5, 0., 0.])\n",
    "    Pc[3] = np.array([1.0, 0., 0.]) \n",
    "    R[0][1] = np.array([[C1, -S1, 0],\n",
    "                        [S1,  C1, 0],\n",
    "                        [ 0,   0, 1],\n",
    "                        ])\n",
    "    R[1][2] = np.array([[C2, -S2, 0],\n",
    "                        [S2,  C2, 0],\n",
    "                        [ 0,   0, 1],\n",
    "                        ])\n",
    "    R[2][3] = np.array([[C3, -S3, 0],\n",
    "                        [S3,  C3, 0],\n",
    "                        [ 0,   0, 1],\n",
    "                        ])\n",
    "\n",
    "    R[3][4] = np.array([[1, 0, 0],\n",
    "                        [0.0,  1.0, 0],\n",
    "                        [ 0,   0, 1],\n",
    "                        ])\n",
    "    \n",
    "    \n",
    "    I[1] = np.array([[0, 0, 0],\n",
    "                     [0, 0, 0],\n",
    "                     [0, 0, 0.5],\n",
    "                    ])\n",
    "    \n",
    "    I[2] = np.array([[0, 0, 0],\n",
    "                     [0, 0, 0],\n",
    "                     [0, 0, 0.2],\n",
    "                    ])\n",
    "    \n",
    "    I[3] = np.array([[0, 0, 0],\n",
    "                     [0, 0, 0],\n",
    "                     [0, 0, 0.1],\n",
    "                    ])\n",
    "\n",
    "    w = [np.array([0., 0., 0.])]\n",
    "    w_d = [np.array([0., 0., 0.])]\n",
    "    v_d = [np.array([0., 9.81, 0.])]\n",
    "    vc_d = [np.array([0., 0., 0.])]\n",
    "    F = [np.array([0., 0., 0.])]\n",
    "    N = [np.array([0., 0., 0.])]\n",
    "\n",
    "    for i in range(3):\n",
    "        w.append(np.matmul(np.linalg.inv(R[i][i+1]), w[i]) + np.array([0., 0., theta_d[i+1]]))\n",
    "        w_d.append(np.matmul(np.linalg.inv(R[i][i+1]), w_d[i]) + np.cross(np.matmul(np.linalg.inv(R[i][i+1]), w[i]), np.array([0., 0., theta_d[i+1]])) + np.array([0., 0., theta_dd[i+1]]))\n",
    "        v_d.append(np.matmul(np.linalg.inv(R[i][i+1]), np.cross(w_d[i], P[i][i+1]) + np.cross(w[i], np.cross(w[i], P[i][i+1])) + v_d[i]))\n",
    "        vc_d.append(np.cross(w_d[i+1], Pc[i+1]) + np.cross(w[i+1], np.cross(w[i+1], Pc[i+1])) + v_d[i+1])\n",
    "        F.append(m[i+1] * vc_d[i+1])\n",
    "        N.append(np.matmul(I[i+1], w_d[i+1]) + np.matmul(np.cross(w[i+1], I[i+1]), w[i+1]))\n",
    "\n",
    "    print(w)\n",
    "    print(w_d)\n",
    "    print(v_d)\n",
    "    print(vc_d)\n",
    "    print(F)\n",
    "    print(N)\n",
    "    \n",
    "    for i in range(3, 0, -1):\n",
    "        f[i] = np.matmul(R[i][i+1], f[i+1]) + F[i]\n",
    "        n[i] = N[i] + np.matmul(R[i][i+1], n[i+1]) + np.cross(Pc[i], F[i]) + np.cross(P[i][i+1],np.matmul(R[i][i+1], f[i+1]))\n",
    "        \n",
    "    return f, n\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([0., 0., 0.]), array([0., 0., 1.]), array([0., 0., 3.]), array([0., 0., 6.])]\n",
      "[array([0., 0., 0.]), array([0. , 0. , 0.5]), array([0. , 0. , 1.5]), array([0., 0., 3.])]\n",
      "[array([0.  , 9.81, 0.  ]), array([1.70348862, 9.66096406, 0.        ]), array([ 1.8302698 , 11.74317503,  0.        ]), array([-13.67603824,  26.65186731,   0.        ])]\n",
      "[array([0., 0., 0.]), array([-0.29651138, 10.66096406,  0.        ]), array([-11.6697302 ,  13.99317503,   0.        ]), array([-49.67603824,  29.65186731,   0.        ])]\n",
      "[array([0., 0., 0.]), array([ -5.93022754, 213.21928114,   0.        ]), array([-175.04595295,  209.89762539,    0.        ]), array([-496.76038244,  296.51867309,    0.        ])]\n",
      "[array([0., 0., 0.]), array([0.  , 0.  , 0.25]), array([0. , 0. , 0.3]), array([0. , 0. , 0.3])]\n",
      "[None, array([-788.66673436,  160.6472875 ,    0.        ]), array([-753.51240027,  218.31013776,    0.        ]), array([-496.76038244,  296.51867309,    0.        ]), array([0., 0., 0.])]\n",
      "[None, array([  0.        ,   0.        , 853.60323601]), array([  0.        ,   0.        , 637.20264829]), array([  0.        ,   0.        , 296.81867309]), array([0., 0., 0.])]\n"
     ]
    }
   ],
   "source": [
    "f, n = getResultsByHandInExp6()\n",
    "print(f)\n",
    "print(n)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "79c38198e3a853eeea51b70a0ae21c719ed1444592bdd4a45c4de9d24fbfec7c"
  },
  "kernelspec": {
   "display_name": "Python 3.7.7 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
